////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018 Qualcomm Technologies, Inc.
// All Rights Reserved.
// Confidential and Proprietary - Qualcomm Technologies, Inc.
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// THIS IS AUTO-GENERATED CODE.  PLEASE DO NOT EDIT (File bug reports against tools).
///
/// Auto-generated by: ParameterParser V1.1.4
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// @file  aftofelements.h
/// @brief Auto-generated Chromatix parameter file
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef AFTOFELEMENTS_H
#define AFTOFELEMENTS_H

#include "parametermodule.h"
#include "parameterfilesymboltable.h"
#include "parametertypes.h"

#define AFTOFELEMENTS_NAMESPACE_BEGIN namespace aftofelements {
#define AFTOFELEMENTS_NAMESPACE_END }

AFTOFELEMENTS_NAMESPACE_BEGIN

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFSceneChangeType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFSceneChangeType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// scene_change_distance_std_dev_thres
    ///
    /// Description:   Standard deviation of distance across num_monitor_samples, Effect: Larger the number, easy to trigger
    ///                scene change.
    /// Range:         [1,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  scene_change_distance_std_dev_thres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// far_distance_unstable_cnt_factor
    ///
    /// Description:   Trigger for far distance, number of frames to wait should be smaller so in bright light normal_light_cnt
    ///                will be divided by far_distance_unstable_cnt_factor in low light lowlight_cnt will be divided by
    ///                far_distance_unstable_cnt_factor. Effect: Larger the number, easy to trigger scene change.
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  far_distance_unstable_cnt_factor;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// panning_stable_cnt
    ///
    /// Description:   Number of frames the TOF to be considered to be stable higher the number longer the TOF takes to converge
    ///                or trigger far_converge_point Effect: Smaller the number, easy to trigger scene change.
    /// Range:         [1,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  panning_stable_cnt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// panning_stable_thres
    ///
    /// Description:   Threshold below which is the average distance is considered to be stable, Bigger the number its easy for
    ///                TOF to be stable. Effect: Bigger the number, easy to trigger scene change.
    /// Range:         [1,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  panning_stable_thres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// normal_light_cnt
    ///
    /// Description:   Number of frames to monitor to detect scene change in bright light level condition.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  normal_light_cnt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// lowlight_cnt
    ///
    /// Description:   Number of frames to monitor to detect scene change in low light level condition.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  lowlight_cnt;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_monitor_samples
    ///
    /// Description:   number of frames to calculate the average depth used in tof scene change detection.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32  num_monitor_samples;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// scene_change_distance_thres - Array
    ///
    /// Description:   Distance in mm difference treated as scene change.
    /// Range:         [0,1000]
    /// Min Length:    1
    /// Max Length:    8
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 scene_change_distance_thresCount;
    UINT32 scene_change_distance_thresID;
    INT32* scene_change_distance_thres;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// distance_region - Array
    ///
    /// Description:   Divide the distance in mm range to DOF regions, each part will have its own distance_threshold.
    /// Range:         [0,10000]
    /// Min Length:    1
    /// Max Length:    8
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 distance_regionCount;
    UINT32 distance_regionID;
    INT32* distance_region;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFFineScanType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFFineScanType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_near_steps_near_direction
    ///
    /// Description:   Number of steps to get tolerance lens position from center to near in fine search when the direction is
    ///                towards near_end.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 num_near_steps_near_direction;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_far_steps_near_direction
    ///
    /// Description:   Number of steps to get tolerance lens position from center to far in fine search when the direction is
    ///                towards near_end.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 num_far_steps_near_direction;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_near_steps_far_direction
    ///
    /// Description:   Number of steps to get tolerance lens position from center to near in fine search when the direction is
    ///                towards far_end.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 num_near_steps_far_direction;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_far_steps_far_direction
    ///
    /// Description:   Number of steps to get tolerance lens position from center to far in fine search when the direction is
    ///                towards far_end.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 num_far_steps_far_direction;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_near_steps_far_converge_point
    ///
    /// Description:   Number of steps to get tolerance lens position from far_converge_point to get near_lens_limit. Higher the
    ///                number large the fine search range.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 num_near_steps_far_converge_point;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// num_far_steps_far_converge_point
    ///
    /// Description:   Number of steps to get tolerance lens position from far_converge_point to get far_lens_limit. Higher the
    ///                number large the fine search range Effect: The larger, the more accurate in fine search (less likely that
    ///                real lens position will be outside the range); however, it will hurt the speed.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 num_far_steps_far_converge_point;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// near_steps_far_direction_tof_conf
    ///
    /// Description:   Number of steps to get tolerance lens position from center to near in fine search when the direction is
    ///                towards far_end and when TOF is confident Higher the number large the fine search range. Effect: The
    ///                larger, the more accurate in fine search (less likely that real lens position will be outside the range);
    ///                however, it will hurt the speed.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 near_steps_far_direction_tof_conf;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tof_step_size
    ///
    /// Description:   Step size to be used for fine search in bright light level condition. Effect: Higher the number faster
    ///                the AF speed but the accuracy may get effected.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 tof_step_size;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// tof_step_size_low_light
    ///
    /// Description:   Step size to be used for fine search in low light level condition. Effect: Higher the number faster the
    ///                AF speed but the accuracy may get effected.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 tof_step_size_low_light;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// far_distance_fine_step_size
    ///
    /// Description:   Use this step size when the distance of the object is beyond the TOF estimation. light level condition.
    ///                Effect: Higher the number faster the AF speed but the accuracy may get effected
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 far_distance_fine_step_size;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFFocusConvergeType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFFocusConvergeType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// jump_to_start_limit
    ///
    /// Description:   Step size to Jump to the start position of fine search in normal light level. Effect: Higher the number
    ///                faster the AF speed, but will give jerky user experience.
    /// Range:         [0,300]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 jump_to_start_limit;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// jump_to_start_limit_low_light
    ///
    /// Description:   Step size to Jump to the start position of fine search in low light level. Effect: Higher the number
    ///                faster the AF speed, but will give jerky user experience.
    /// Range:         [0,300]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 jump_to_start_limit_low_light;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// start_pos_for_tof
    ///
    /// Description:   Starting lens position when the camera is launched of previous iteration PD error. range is Lens
    ///                position[SINGLE_NEAR_LIMIT_IDX, SINGLE_FAR_LIMIT_IDX].
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 start_pos_for_tof;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// far_converge_point
    ///
    /// Description:   Starting Lens position when TOF focuses from the far direction and when TOF is not confident. range is
    ///                Lens position[SINGLE_NEAR_LIMIT_IDX, SINGLE_FAR_LIMIT_IDX].
    /// Range:         [0,10000]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 far_converge_point;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFFrameDelayType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFFrameDelayType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_delay_focus_converge_bright_light
    ///
    /// Description:   Frame delay to be used during Focus converge in bright light. Effect: Higher the number, slower will be
    ///                the AF speed but user experience will be good.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 frame_delay_focus_converge_bright_light;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_delay_focus_converge_low_light
    ///
    /// Description:   Frame delay to be used during Focus converge in low light. Effect: Higher the number, slower will be the
    ///                AF speed but user experience will be good.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 frame_delay_focus_converge_low_light;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_delay_fine_search_bright_light
    ///
    /// Description:   Frame delay to be used during Fine search in bright light. Effect: Higher the number, slower will be the
    ///                AF speed but user experience will be good and FV stats will be good.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 frame_delay_fine_search_bright_light;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_delay_fine_search_low_light
    ///
    /// Description:   Frame delay to be used during Fine search in low light. Effect: Higher the number, slower will be the AF
    ///                speed but user experience will be good and FV stats will be good.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 frame_delay_fine_search_low_light;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// frame_delay_outdoor_light
    ///
    /// Description:   Frame delay to be used during Fine search in outdoor light Effect: Higher the number, slower will be the
    ///                AF speed but user experience will be good.
    /// Range:         [0,10]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 frame_delay_outdoor_light;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFFlagType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFFlagType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// use_custom_sensitivity
    ///
    /// Description:   Flag to use the sensitivity from the header file rather than using algorithm's default sensitivity.
    ///                Effect: If enabled, TOF algorithm reads sensitivity value from the header, else TOF algorithm calculates
    ///                the sensitivity by default.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 use_custom_sensitivity;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// enable_sad_when_tof_is_conf
    ///
    /// Description:   Flag to use SAD even when TOF is confident. Default value : 0 for camcorder, 1 for preview. Effect: If
    ///                disabled, SAD wont be used as scene change detection metric when TOF is confident.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 enable_sad_when_tof_is_conf;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// run_tof_in_outdoor_light_flag
    ///
    /// Description:   Flag to run TOF even in outdoor light level.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 run_tof_in_outdoor_light_flag;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// aec_wait_check_flag_enable
    ///
    /// Description:   Flag to check AEC wait before trigger AF search. Effect: If enabled, AF speed will be effected but
    ///                accuracy will be improved.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 aec_wait_check_flag_enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// far_scene_coarse_srch_enable
    ///
    /// Description:   Flag to use to Contrast AF when TOF is not confident in Far objects. Effect: If enabled, AF speed will be
    ///                effected but accuracy will be improved.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 far_scene_coarse_srch_enable;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFFilterType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFFilterType
{

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// median_filter_enable
    ///
    /// Description:   Flag to run the median filter on the TOF raw data. Effect: Enabling this flag to make median filter to be
    ///                run on raw TOF data so as to reduce the noise in the TOF data, but running median filter would cause the
    ///                delay in response.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 median_filter_enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// median_filter_num_of_samples
    ///
    /// Description:   Number of frames to run the median filter. Constraint : The number of frames has to be always odd for
    ///                median filter. Effect: Higher the number slower the response but chances of reducing the noise is more.
    /// Range:         [0,100]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 median_filter_num_of_samples;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// average_filter_enable
    ///
    /// Description:   TODO_DESCRIPTION
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 average_filter_enable;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// average_filter_num_of_samples
    ///
    /// Description:   Flag to run the averaging filter on the TOF raw data. Effect: Enabling this flag to make average filter
    ///                to be run on raw TOF data so as to reduce the noise in the TOF data, but running average filter would
    ///                cause the delay in response.
    /// Range:         [0,1]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32 average_filter_num_of_samples;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFType
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
struct chromatixTOFType
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Binary file symbol table entry ID
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    UINT32 SymbolTableID;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// module_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct module_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } module_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// parameter_version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    struct parameter_versionStruct
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// Binary file symbol table entry ID
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        UINT32 SymbolTableID;
        INT32 major_revision;
        INT32 minor_revision;
    } parameter_version;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// sensitivity
    ///
    /// Description:   Sensitivity of the image sensor module
    /// Range:         [0,5]
    /// Conversion:    NA
    /// Notes:         -
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    FLOAT                         sensitivity;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// outdoorLuxIdx
    ///
    /// Description:    Threshold to determine the outdoor light level so as to switch from TOF to Contrast AF. Effect: Below
    ///                this threshold, Contrast AF will be active. Above the threshold Laser AF will be active. Constraints:
    ///                Check the chromatix header to know the exact lux index threshold for bright light or outdoor light
    ///                condition.
    /// Range:         [0,500]
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    INT32                         outdoorLuxIdx;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// TOFFlag
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFFlagType          TOFFlag;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Filter
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFFilterType        Filter;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FrameDelay
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFFrameDelayType    FrameDelay;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// SceneChange
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFSceneChangeType   SceneChange;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FocusConverge
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFFocusConvergeType FocusConverge;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// FineScan
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFFineScanType      FineScan;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// chromatixTOFTypeClass
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class chromatixTOFTypeClass : public ParameterModule, public chromatixTOFType
{
public:
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Version
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const UINT16 MAJOR = 3;
    static const UINT16 MINOR = 4;
    static const UINT32 PATCH = 0;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Default Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFTypeClass(
        const CHAR* name);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Constructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    chromatixTOFTypeClass(
        const CHAR* name,
        UINT32 modeId,
        UINT16 mode,
        UINT16 subMode,
        UINT32 group);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Destructor
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ~chromatixTOFTypeClass();

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// GetName
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static const CHAR* GetName(
        const CHAR* type);


    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFSceneChangeType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFSceneChangeType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFSceneChangeType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFFineScanType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFFineScanType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFFineScanType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFFocusConvergeType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFFocusConvergeType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFFocusConvergeType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFFrameDelayType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFFrameDelayType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFFrameDelayType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFFlagType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFFlagType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFFlagType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFFilterType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFFilterType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFFilterType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load chromatixTOFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL LoadchromatixTOFType(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load module_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadmodule_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFType::module_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Load parameter_versionStruct
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static BOOL Loadparameter_versionStruct(
        ParameterFileSymbolTableEntry* entry,
        chromatixTOFType::parameter_versionStruct* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixTOFSceneChangeType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixTOFSceneChangeType(
        chromatixTOFSceneChangeType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Unload chromatixTOFType
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static void UnloadchromatixTOFType(
        chromatixTOFType* structure);

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /// Parse symbol table entry, and return a new object
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    virtual ParameterModule* Parse(
        ParameterSetManager* manager,
        ParameterFileSymbolTableEntry* entry) const;

}; // End class chromatixTOFTypeClass

AFTOFELEMENTS_NAMESPACE_END
#endif // AFTOFELEMENTS_H

